As computers become increasingly powerful, software engineers design ever more complicated computer software applications to take advantage of the available processing power. With the increase in complexity of computer software applications, however, comes an increase in the generation of unexpected exceptions by such applications. When an application generates such an unexpected exception, people say in common parlance that the application has crashed.
When an application crashes (i.e., generates an unexpected exception), the application is shut down by the operating system and the user is denied the continued use of that application session. In other words, the crashing application may prevent the user's computer from further responding to the user in any meaningful way. Another unwanted consequence caused by an application crashing is that the user may lose valuable data that the application was processing prior to the crash.
To help mitigate the consequences to the user of a given application crashing, programmers have in the past added code to the application that is run upon the generation of an otherwise unexpected exception. Typically, this code may attempt to learn enough about the problem to allow the application to proceed in a useful manner. Such code may also attempt data recovery where data has been lost.
Unfortunately, adding code to the application to handle an unexpected exception is not an entirely satisfactory solution to the problems created by a crashing application. For example, the problem that caused the unexpected exception also typically interferes with proper functioning of the application's code for responding to the unexpected exception. Thus, a crashing application may nonetheless cause the user's computer to freeze even though the application contains code for responding to an unexpected exception. When the application malfunctions in this manner, there is no simple way for the user to discover the source of the problem in order to fix the problem. Therefore, there is a need in the art for an improved method for responding to the generation of an unexpected exception by an application.